////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  aecconvergence.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AECCONVERGENCE_H
#define AECCONVERGENCE_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "globalelements.h"
#include "aecglobalelements.h"

#define AECCONVERGENCE_NAMESPACE_BEGIN namespace aecConvergence {
#define AECCONVERGENCE_NAMESPACE_END }

AECCONVERGENCE_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SlowConvHoldTimeType
///
/// Description:   These parameters control how long the algorithm will hold off adjusting in the presence of stats changes
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SlowConvHoldTimeType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableHoldTime
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable holding off exposure adjustments when motion and exposure changes are small
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL         enableHoldTime;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresAbsExpDelta
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range within which hold time is adjusted based on exposure deviation from target. Below this range: hold
    ///                time is adjusted by expDeltaBasedHTAdjFactor.start; above this range hold time is adjusted by
    ///                expDeltaBasedHTAdjFactor.end
    /// Range:         [2.0,6.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType thresAbsExpDelta;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// expDeltaBasedHTAdjFactor
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Exposure-based hold time adjustment factor range, start needs to be larger than end!
    /// Range:         [1.0,0.3]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType expDeltaBasedHTAdjFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolAdjFactor
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Hold time is not allowed if exposure index absolute delta from target is larger than tolerance times this
    ///                threshold
    /// Range:         [1,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32        tolAdjFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// holdTimeEnterDelay
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   The amount of time AEC needs to be stable before holding time gets activated
    /// Range:         [1.0,10.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        holdTimeEnterDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxHoldTime
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Maximum amount of time AEC will hold off exposure adjustments when large disturbance is measured
    /// Range:         [0,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        maxHoldTime;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableGyroBasedHT
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable using gyro to determine amount of disturbance
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL         enableGyroBasedHT;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresGyroMagnitude
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range within which hold time is adjusted based on gyro magnitude. Amount of adjustment is controlled by
    ///                gyroBasedHTAdjFactor
    /// Range:         [0.1,10.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType thresGyroMagnitude;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gyroBasedHTAdjFactor
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Gyro-based hold time adjustment factor range, start needs to be larger than end!
    /// Range:         [1.0,0.3]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType gyroBasedHTAdjFactor;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SlowConvType
///
/// Description:   Slow algorithm converges smoothly by using exposure index steps the size of which increases or decreases
///                gracefully at the expense of convergence speed
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SlowConvType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolMultUnitStepSize
    ///
    /// Tuning Level:  often_tune
    /// Description:   Exposure index tolerance is tolMultUnitStepSize * unitStepSize; exposure index range within which AEC
    ///                will not adjust
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                tolMultUnitStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkipMethod
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Specifies which type of frame skip is desired: SmoothNoSkip for smooth convergence, SkipOne if there are
    ///                sync issues. Slow convergence does not implement SkipSystemLatency
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ConvFrameSkipType    frameSkipMethod;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepFactorWhenFrameSkipEnabled
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Increase in step size when skip is enabled
    /// Range:         [1.5,2.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                stepFactorWhenFrameSkipEnabled;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// convSpeed
    ///
    /// Tuning Level:  often_tune
    /// Description:   Controls convergence speed; larger value will result in larger step sizes and therefore faster
    ///                convergence
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                convSpeed;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// refFrameRate
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Reference frame rate at which the tuning settings were computed
    /// Range:         [15.0,120.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                refFrameRate;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepRegular
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range of step sizes for slow convergence when there are no dark or bright regions. Final step size is
    ///                interpolated based on convSpeed parameter
    /// Range:         [2.0,6.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType         stepRegular;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepDark
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range of step sizes for slow convergence when exposure is too dark and there are dark regions. Final step
    ///                size is interpolated based on convSpeed parameter
    /// Range:         [6.0,30.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType         stepDark;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBright
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range of step sizes for slow convergence when exposure is too bright and there are bright regions. Final
    ///                step size is interpolated based on convSpeed parameter
    /// Range:         [5.0,18.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType         stepBright;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresSlowDownAbsExpIndexDeltaDark
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range of absolute exposure delta from target whithin which algorithm step size will be decreased to
    ///                smoothly converge to target. Large value means slower approach. Final step size is interpolated based on
    ///                convSpeed parameter
    /// Range:         [6.0,20.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType         thresSlowDownAbsExpIndexDeltaDark;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresSlowDownAbsExpIndexDeltaBright
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Range of absolute exposure delta from target whithin which algorithm step size will be decreased to
    ///                smoothly converge to target. Large value means slower approach. Final step size is interpolated based on
    ///                convSpeed parameter
    /// Range:         [6.0,20.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType         thresSlowDownAbsExpIndexDeltaBright;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxRawStepAdj
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Slow convergence algorithm is designed to maintain the same convergence speed, regardless of skip and
    ///                frame rate. To that effect, the step size is adjusted by a factor. Parameter maxRawStepAdj controls the
    ///                range of that factor: [1/maxRawStepAdj, maxRawStepAdj]
    /// Range:         [1.0,2.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                maxRawStepAdj;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolExpIndexDeltaForceAdj
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   If computed step size is zero we will force it to unitStepSize when absolute delta from target is larger
    ///                than this threshold
    /// Range:         [2,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                tolExpIndexDeltaForceAdj;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresNumBrightRgn
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   The minimal ratio of bright regions required for bright step size to be used during convergence
    /// Range:         [0.03,0.1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                thresNumBrightRgn;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresNumDarkRgn
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   The minimal ratio of dark regions required for dark step size to be used during convergence
    /// Range:         [0.03,0.2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                thresNumDarkRgn;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// holdTimeTuning
    ///
    /// Description:   These parameters control how long the algorithm will hold off adjusting in the presence of stats changes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SlowConvHoldTimeType holdTimeTuning;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ADRCConvSpeed
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Convergence speed for short and long exposures. Smaller value yields slower convergence.
    /// Range:         [0.0,0.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                ADRCConvSpeed;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FastConvType
///
/// Description:   Fast algorithm converges by measuring the delta to exposure target and adjusting to take into account
///                system delay.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FastConvType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolMultUnitStepSize
    ///
    /// Tuning Level:  often_tune
    /// Description:   Exposure index tolerance is tolMultUnitStepSize * unitStepSize; exposure index range within which AEC
    ///                will not adjust
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32             tolMultUnitStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkipMethod
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Specifies which type of frame skip is desired: SmoothNoSkip for smooth convergence, SkipOne if there are
    ///                synchronization concerns, SkipSystemLatency if speed is preferred to smoothness
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ConvFrameSkipType frameSkipMethod;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// aggressiveness
    ///
    /// Tuning Level:  often_tune
    /// Description:   Controls convergence speed; 0.0 is slowest and 1.0 is fastest
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             aggressiveness;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableBrightDarkSpeedAdj
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable adjusting convergence speed when there are saturated regions
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL              enableBrightDarkSpeedAdj;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// darkRatioAdjStrength
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Strength of speed adjustment when there are dark clipped regions
    /// Range:         [0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             darkRatioAdjStrength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// brightRatioAdjStrength
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Strength of speed adjustment when there are dark clipped regions
    /// Range:         [0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             brightRatioAdjStrength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresDarkExpIndexDelta
    ///
    /// Tuning Level:  never_tune
    /// Description:   When image is dark and absolute index target delta is larger than this absolute threshold we will adjust
    ///                convergence speed
    /// Range:         [40,80]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             thresDarkExpIndexDelta;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBrightExpIndexDelta
    ///
    /// Tuning Level:  never_tune
    /// Description:   When image is bright and absolute index target delta is larger than this absolute threshold we will
    ///                adjust convergence speed
    /// Range:         [10,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             thresBrightExpIndexDelta;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ADRCConvSpeed
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Convergence speed for short and long exposures. Smaller value yields slower convergence.
    /// Range:         [0.0,0.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             ADRCConvSpeed;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECCoreConvergenceType
///
/// Description:   Convergence Module controls how AEC adjusts the exposure in order to reach the desired exposure index
///                target
/// Comments:       Core Convergence Tuning Definition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AECCoreConvergenceType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
        INT32 incr_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// algoSelect
    ///
    /// Tuning Level:  often_tune
    /// Description:   Specifies which algorithm to run in preview state: AECConvSlowConv or AECConvFastConv. Slow is recommeded
    ///                for smooth video capture and Fast for preview
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::AECConvAlgoType algoSelect;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fastConv
    ///
    /// Description:   Fast algorithm converges by measuring the delta to exposure target and adjusting to take into account
    ///                system delay.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FastConvType    fastConv;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// slowConv
    ///
    /// Description:   Slow algorithm converges smoothly by using exposure index steps the size of which increases or decreases
    ///                gracefully at the expense of convergence speed
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SlowConvType    slowConv;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// unitStepSize
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Base exposure index unit
    /// Range:         [0.1,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT           unitStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableConvergeGainFirst
    ///
    /// Tuning Level:  often_tune
    /// Description:   Speeds up dark to bright convergence by increasing gain first
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL            enableConvergeGainFirst;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECCoreConvergenceTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class AECCoreConvergenceTypeClass : public ParameterModule, public AECCoreConvergenceType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 1;
    static const UINT16 MINOR = 0;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECCoreConvergenceTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECCoreConvergenceTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~AECCoreConvergenceTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SlowConvHoldTimeType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSlowConvHoldTimeType(
        ParameterFileSymbolTableEntry* entry,
        SlowConvHoldTimeType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SlowConvType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSlowConvType(
        ParameterFileSymbolTableEntry* entry,
        SlowConvType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FastConvType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFastConvType(
        ParameterFileSymbolTableEntry* entry,
        FastConvType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load AECCoreConvergenceType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadAECCoreConvergenceType(
        ParameterFileSymbolTableEntry* entry,
        AECCoreConvergenceType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        AECCoreConvergenceType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class AECCoreConvergenceTypeClass

AECCONVERGENCE_NAMESPACE_END
#endif // AECCONVERGENCE_H

